High performance design rule checking technique

ABSTRACT

Roughly described, a design rule data set is developed offline from the design rules of a target fabrication process. A design rule checking method involves traversing the corners of shapes in a layout region, and for each corner, populating a layout topology database with values that depend on respective corner locations. After the layout topology database is populated, the values are compared to values in the design rule data set to detect any design rule violations. Violations can be reported in real time, while the user is manually editing the layout. Preferably corner traversal is performed using scan lines oriented perpendicularly to edge orientations, and scanning in the direction of the edge orientations. Scans stop only at corner positions and populate the layout topology database with what information can be gleaned based on the current scan line. The different scans need not reach each corner simultaneously.

CROSS-REFERENCE TO RELATED APPLICATIONS

This is a Continuation application of pending U.S. Ser. No. 12/960,086filed 3 Dec. 2010.

BACKGROUND

The invention relates to electronic design automation, and moreparticularly, to methods and apparatuses for rapid checking of designrules in a circuit layout.

Advancements in process technology have impacted integrated circuitmanufacturing in at least two key ways. First, scaling of devicegeometry achieved through sub-wavelength lithography has facilitatedpacking more devices on a chip. Second, different process recipes haveenabled manufacturing of heterogeneous devices with different thresholdand supply voltages on the same die. A consequence of theseimprovements, however, has been an explosion in the number of designrules that need to be obeyed in the layout. Instead of simple width andspacing rules, modern fabrication technologies prescribe complexcontextual rules that have to be obeyed for manufacturability.

The increase in the number of rules has complicated the task of creatingdesign rule clean layouts, i.e., layouts that do not have design ruleviolations. Creating design rule clean layouts for digital circuitdesigns can be facilitated by the use of standard cell layouts asbuilding blocks, and placement and routing tools that are extended toaddress the design rules.

Unfortunately, this approach usually does not work for analog, RF andcustom circuit designs. Layouts for such designs are typically createdmanually using layout editors, and because of the number and complexityof the design rules, checking them was a laborious process.

A conventional design rule check (DRC) system requires a powerfultwo-dimensional geometry engine which supports geometric operations suchas Boolean operations like AND, OR, NOT, XOR; sizing operations likegrow/shrink horizontal/vertical/diagonal; other operations like merge,shift, flip, cut, smooth; as well as all-angle geometry for trueEuclidean distance calculations. Individual rules are typically checkedindividually over an entire layout region. This is also true ofindividual rule values of same rule (e.g. a check against the minimumvalue for a rule, and another check against a preferred value for thesame rule). Each check basically runs an independent sequence ofgeometry operations, and numerous passes through the layout region arerequired.

For example, a conventional series of operations to check a minimumspacing rule in a Manhattan only layout, might include steps of

-   -   Merge all same layer shapes into separate islands;    -   Grow all islands by half the minimum spacing value;    -   Perform an AND (intersection) operation among the islands; and    -   Draw DRC violation markers based on the resulting shapes of the        AND operation.

As another example, a conventional series of operations to check aminimum width rule in a Manhattan only layout, might include steps of

-   -   Merge all same layer shapes into separate islands;    -   Shrink all islands by (half the minimum width value+epsilon)    -   Eliminate all resulting islands of zero area;    -   Grow back the resulting islands by (half the minimum width        value+epsilon);    -   Perform a NOT operation between the original merged islands and        grown back islands; and    -   Draw DRC violation markers based on the shapes resulting from        the NOT operation.

So long as a good geometry engine is available, the conventional DRCtechniques are simple to code, at least for simple rules. They are alsoflexible and powerful if the geometry engine has a scripting API forrelevant geometry operations, and it is relatively straightforward tomassively parallelize the DRC process among numerous CPUs.

On the other hand, it can be seen that checking even simple design ruleslike those above is extremely expensive computationally. Massiveparallelization usually is possible only for offline checks, whichtypically are performed only between layout iterations. Even then theyoften can require hours to complete. The conventional approach alsosuffers from roughly linear growth of the total run time with respect tothe number of rules to be checked, with multiple values for a rulecounted as separate rules. This makes it very hard to reduce the totalrun time without turning off selected rules. The conventional approachalso suffers from linear growth of run time for individual rule checks,with respect to the length of the geometry operation sequence, i.e., thecomplexity of the rule. The conventional approach also involves separatechecks for Euclidean measurements, and also requires extensive educationand training in order to optimize the performance of the customerscripts.

The manual layout editing process could be drastically facilitated ifdesign rule checking could be performed in real time, that is,immediately after each geometric manipulation made by the designer.While some layout editors are able to do this, the checking can besluggish and usually works only when some of the design rules are turnedoff.

SUMMARY

A need therefore exists for a robust solution to the problem of rapidchecking of design rules during a layout editing process.

Roughly described, a design rule data set is developed offline based onthe design rules of a target fabrication process. A design rule checkingmethod then involves traversing the corners of shapes in a subjectlayout region, and for each corner, populating a layout topologydatabase with values that depend on the respective corner locations.After the layout topology database has been populated, the values arecompared to values in the design rule data set to detect any violationsof design rules. Any violations can be reported to a user in real time,while the user is manually editing the layout.

Preferably corner traversal is performed using scan lines orientedperpendicularly to edge orientations, and scanning in the direction ofthe edge orientations. Scans stop only at corner positions and populatethe layout topology database with what information can be gleaned basedon the current scan line. The different scans need not reach each cornersimultaneously.

The above summary of the invention is provided in order to provide abasic understanding of some aspects of the invention. This summary isnot intended to identify key or critical elements of the invention or todelineate the scope of the invention. Its sole purpose is to presentsome concepts of the invention in a simplified form as a prelude to themore detailed description that is presented later. Particular aspects ofthe invention are described in the claims, specification and drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention will be described with respect to specific embodimentsthereof, and reference will be made to the drawings, in which:

FIG. 1 shows a simplified representation of an illustrative digitalintegrated circuit design flow.

FIG. 2 is a flow chart illustrating an example user experience whenusing an embodiment of the system as described herein.

FIG. 3 is a flow chart of the overall system flow for an embodiment ofthe invention.

FIGS. 4, 7-10, 12-18, 20 and 23 are flow chart details of the overallsystem flow in FIG. 3.

FIG. 5 illustrates part of a sweep_x data structure referred to in FIG.4.

FIG. 6 illustrates part of a sweep_y data structure referred to in FIG.4.

FIGS. 11A and 11B illustrate simple portions of a layout, highlightingconvex and concave corners of a layout shape, respectively.

FIGS. 19A, 19B and 19C illustrate certain corner relationships betweenlayout shapes.

FIG. 19D illustrates two layout shapes for the purpose of a particulardesign rule check.

FIG. 19E illustrates three layout shapes together forming an island.

FIGS. 21A-21E illustrate example visual indications of design ruleviolations and near-violations.

FIG. 22 is a simplified block diagram of a computer system that can beused to implement software incorporating aspects of the presentinvention.

DETAILED DESCRIPTION

The following description is presented to enable any person skilled inthe art to make and use the invention, and is provided in the context ofa particular application and its requirements. Various modifications tothe disclosed embodiments will be readily apparent to those skilled inthe art, and the general principles defined herein may be applied toother embodiments and applications without departing from the spirit andscope of the present invention. Thus, the present invention is notintended to be limited to the embodiments shown, but is to be accordedthe widest scope consistent with the principles and features disclosedherein.

Overall Design Process Flow

FIG. 1 shows a simplified representation of an illustrative digitalintegrated circuit design flow. At a high level, the process starts withthe product idea (step 100) and is realized in an EDA (Electronic DesignAutomation) software design process (step 110). When the design isfinalized, it can be taped-out (step 127). At some point after tape out,the fabrication process (step 150) and packaging and assembly processes(step 160) occur resulting, ultimately, in finished integrated circuitchips (result 170).

The EDA software design process (step 110) is itself composed of anumber of steps 112-130, shown in linear fashion for simplicity. In anactual integrated circuit design process, the particular design mighthave to go back through steps until certain tests are passed. Similarly,in any actual design process, these steps may occur in different ordersand combinations. This description is therefore provided by way ofcontext and general explanation rather than as a specific, orrecommended, design flow for a particular integrated circuit.

A brief description of the component steps of the EDA software designprocess (step 110) will now be provided.

System design (step 112): The designers describe the functionality thatthey want to implement, they can perform what-if planning to refinefunctionality, check costs, etc.

Hardware-software architecture partitioning can occur at this stage.Example EDA software products from Synopsys, Inc. that can be used atthis step include Model Architect, Saber, System Studio, and DesignWare®products.

Logic design and functional verification (step 114): At this stage, theVHDL or Verilog code for modules in the system is written and the designis checked for functional accuracy. More specifically, the design ischecked to ensure that it produces correct outputs in response toparticular input stimuli. Example EDA software products from Synopsys,Inc. that can be used at this step include VCS, VERA, DesignWare®,Magellan, Formality, ESP and LEDA products.

Synthesis and design for test (step 116): Here, the VHDL/Verilog istranslated to a netlist. The netlist can be optimized for the targettechnology. Additionally, the design and implementation of tests topermit checking of the finished chip occurs. Example EDA softwareproducts from Synopsys, Inc. that can be used at this step includeDesign Compiler®, Physical Compiler, DFT Compiler, Power Compiler, FPGACompiler, TetraMAX, and DesignWare® products.

Netlist verification (step 118): At this step, the netlist is checkedfor compliance with timing constraints and for correspondence with theVHDL/Verilog source code. Example EDA software products from Synopsys,Inc. that can be used at this step include Formality, PrimeTime, and VCSproducts.

Design planning (step 120): Here, an overall floor plan for the chip isconstructed and analyzed for timing and top-level routing. Example EDAsoftware products from Synopsys, Inc. that can be used at this stepinclude Astro and Custom Designer products.

Physical implementation (step 122): The placement (positioning ofcircuit elements) and routing (connection of the same) occurs at thisstep. Example EDA software products from Synopsys, Inc. that can be usedat this step include the Astro, IC Compiler, and Custom Designerproducts. Aspects of the invention can be performed during this step122.

Analysis and extraction (step 124): At this step, the circuit functionis verified at a transistor level, this in turn permits what-ifrefinement. Example EDA software products from Synopsys, Inc. that canbe used at this step include AstroRail, PrimeRail, PrimeTime, andStar-RCXT products.

Physical verification (step 126): At this step various checkingfunctions are performed to ensure correctness for: manufacturing,electrical issues, lithographic issues, and circuitry. Example EDAsoftware products from Synopsys, Inc. that can be used at this stepinclude the Hercules product. Aspects of the invention can be performedduring this step 126 as well.

Tape-out (step 127): This step provides the “tape-out” data to be used(after lithographic enhancements are applied if appropriate) forproduction of masks for lithographic use to produce finished chips.Example EDA software products from Synopsys, Inc. that can be used atthis step include the IC Compiler and Custom Designer families ofproducts.

Resolution enhancement (step 128): This step involves geometricmanipulations of the layout to improve manufacturability of the design.Example EDA software products from Synopsys, Inc. that can be used atthis step include Proteus, ProteusAF, and PSMGen products.

Mask data preparation (step 130): This step provides mask-making-ready“tape-out” data for production of masks for lithographic use to producefinished chips. Example EDA software products from Synopsys, Inc. thatcan be used at this step include the CATS(R) family of products.

Overview of the Technique

While DRC layout rules are becoming more and more complex at smaller andsmaller technology nodes, most if not all of them still can bedecomposed into a combination of the relationships among the edges, thecorners, and the contours of shapes in the layout. Relationships “among”shapes as used herein includes relationships about a single shape aswell. In embodiments herein, multiple perpendicular scan lines are usedto collect all the required data in one pass, so that the combinatorialchecking on the data is virtually free. The pass speed is improved evenfurther by stopping the scan lines only at corner positions. Note thatscans in multiple directions can also be combined an a particularembodiment, so that the algorithm effectively jumps from corner tocorner, considering each corner only once.

In a Manhattan layout, all edges of all shapes are oriented eitherhorizontally or vertically. In this case two scan lines would be used,one vertical (scanning horizontally) and one horizontal (scanningvertically). In each case the scan line stops only at endpoints that itencounters of the edges that are oriented perpendicularly to the scanline. The vertical scan line, for example, stops only at endpoints ofhorizontally oriented edges, and the horizontal scan line stops only atendpoints of vertically oriented edges. In 45 degree layouts, edges canalso be oriented at a 45 degree angle or a 135 degree angle. In thiscase four scan lines can be used, each scanning in a directionperpendicular to a respective one of the orientations in which edges areincluded in the layout. While scanning the layout region in eachparticular direction, “corner” data structures are populated for eachcorner, with whatever information is easily obtainable from the edgeendpoints at the corner, and from other edges that intersect the samescan line. The combined information collected from all the scan lines asthey encounter the corner, is sufficient to fully populate the cornerdata structure.

Other data structures are also populated during a scan, such asinformation about an island (such as its area), and information aboutvias.

Once all the data is collected into a layout topology database, designrule checking is accomplished merely by comparing the numeric values inthe layout topology database with the constraint values in the designrule data set. Unlike geometry engine approaches, the approach describedherein can be performed extremely quickly, often within milliseconds,allowing for design rule checking in real time, immediately as thelayout designer makes each alteration in the layout.

Moreover, since most if not all of the design rules can be framed interms of topological relationships among edges and corners, it can beseen that the same basic information, collected during the scan, can beused in checking most if not all of the design rules. In mostembodiments, there is no need to re-scan the layout region in order tocheck different design rules; one scan is sufficient for collecting allthe needed data. Still further, since the number of topologicalrelationships that can be involved in checking design rules is itselflimited, there is little if any additional data collection needed duringthe scan in order to check new and ever more complex rules. The timerequired to perform DRC increases less than linearly with increasingnumbers of rules, and tapers off to nearly zero.

For example, if minSpacing is supported already, then minSameNetSpacingand minNotchSpacing can be supported for free (no runtime overhead). IfminArea is supported already, then minRectArea can be supported for free(no runtime overhead). If 1D spacing is supported already, then 1Dextension can be supported easily regardless of whether they share thesame “width”. It can be seen that the more rules that are to be checked,the greater the likelihood that the next “new rule” can be supported forfree or with a little extra overhead.

EXAMPLE IMPLEMENTATION

FIG. 2 illustrates an example user experience when using an embodimentof the system as described herein. The flow chart of FIG. 2 occurswithin step 122 (FIG. 1).

In step 210, the user develops a preliminary layout from a circuitdesign. As used herein, the term “circuit design” refers to the gate ortransistor level design, before layout. The circuit design is oftenrepresented internally to the system in a netlist file. The layout isrepresented internally to the system in a geometry file which defines,among other things, all the shapes to be formed on each mask that willbe used to expose the wafer during fabrication. The geometry file canhave any of several standard formats, such as GDSII, OASIS, CREF, and soon, or it can have a non-standard format. The file describes the layoutof the circuit design in the form of a mask definition for each of themasks to be generated. Each mask definition defines a plurality ofpolygons. At the time if FIG. 2, no resolution enhancement (RET) has yetbeen performed. Thus the layout geometries with which the user isworking in FIG. 2 are in a sense idealized, since they do not yet takeinto account the imperfections of lithographic printing using opticalwavelengths comparable or larger in size than the size of the geometriesin the layout. For example, rectangles are rectangular, and are not yetpre-corrected for diffractive effects.

In step 212, the user views the layout on a computer monitor. The usertypically selects a region of the layout for magnified viewing, so thatonly that region is visible on the monitor.

In step 214, the user, using a mouse or other pointing device, selects agroup of one or more shapes from the visible layout region and dragsthem to a different location. In step 216, as the user drags the shapes,the system shows on the monitor any design rule violations in real time.In step 218, the user continues to drag the selected shapes until aposition is found at which all design rule violations disappear. Theuser then performs the next desired editing step, which could be anotherdrag-and-drop as in steps 214-218.

It can be seen how useful real time immediate design rule checking,enabled by the system herein, can be in manual layout or layoutmodification efforts.

Relationship Master

Before discussing the methods used by an implementation of the system,it will be useful to discuss design rules in general, and how they canbe represented within the system. Design rules are a set of rules thatare provided by a semiconductor manufacturer, which specify minimum ormaximum geometric relationships among the features of a layout. Asemiconductor manufacturing process always has some variability, and thepurpose of design rules is to ensure that sufficient margin is includedin the layout geometries to minimize the likelihood that the variabilitywill result in loss of yield. A set of design rules is specific to aparticular semiconductor manufacturing process, so new rules areprovided to designers or EDA vendors for each new process or significantprocess change. Despite their specificity to a particular process, thereare many design rules which are similar, except for one or more numericvalues, across many processes.

Design rules range from very simple to very complex. Most, however, canbe framed as a set of one or more constraint parameters, and a set ofone or more constraint values for the constraint parameters. (As usedherein, a “parameter” is merely a slot or container for one or morevalues. It is not itself a value.) For example, a simple design rule isminimum edge-to-edge spacing (sometimes called minSpacing). This rulehas one parameter (edge-to-edge spacing), and one value which is theminimum spacing allowed by the rule between edges in a single layer ofthe layout. Many design rules specify more than one value for aparticular parameter, such as an “absolute minimum” value and a“preferred minimum” value.

More complex rules can have multiple parameters. An End-of-line spacingrule, for example, specifies the minimum spacing between the end of aline and its neighboring geometry. The constraint applies only if thewidth of the wire is less than a specified value, eolWidth. Theconstraint applies when any geometry occurs within a region defined bythe minimum spacing, where the region includes the distance from eachside of the wire. This distance is referred to as a lateral verificationdistance eolWithin. The constraint applies only if one parallel edge iswithin a specified rectangular region from the corners of the wire, orit applies only if two parallel edges are within a specified rectangularregion from the corners of the wire. These parameters are referred to asparWithin and parSpace. The constraint applies when no parallel edgesoccur within the region defined by the minimum spacing, or one paralleledge occurs within the region defined by the minimum spacing, or twoparallel edges. This rule has the spacing parameter itself, eolSpacing,as well as the following parameters: eolWidth, eolWithin, parWithin andparSpace.

Design rules can also specify constraints on edges in different layers.The MinDualExtension layer pair constraint, for example, specifies theminimum distance a shape on one layer must extend past a shape on asecond layer. This rule has one parameter for extensions in thehorizontal direction and another parameter for extensions in thevertical directions. This rule can also specify additional pairs ofparameters, keyed by wire width. Other more complex parameters are alsoavailable for this rule, including optional parameters to qualify whenthe rule applies.

Design rule sets also often include area rules, such as the minimum areaof an island or a hole in a layer. They can also include via rules,which specify constraints on geometric dimensions in the “cut” layer(also sometimes called the via layer), the island in the “cover” layerabove the via, and the island in the “cover” layer below the via.

In an embodiment of the invention, all of the values specified by thedesign rules are provided to the system in the form of a design ruledata set. As used herein, the term “data set” does not imply anyparticular organization. For example, it includes maps, multimaps,trees, as well as ordinary tables, and other data organizations as well.The term also does not necessarily imply any unity or regularity ofstructure. For example, two or more separate data sets, when consideredtogether, still constitute a “data set” as that term is used herein. Theterms “database” and “data structure” are also intended to have the samemeaning as “data set”.

In the present embodiment, the design rule data set is sometimesreferred to herein as the relationship_master. A class definition for anexample relationship_master, in pseudo-C++, is as follows. In order tosimplify the discussion, only some of the parameters are shown.

class relationship_master {  layer_number m_layer; // layer number forthis instantiation  std::set<layer_number> m_layers_above; //identification of layers above current layer  std::set<layer_number>m_layers_below; // identification of layers below current layer  // theworst case value for spacing relationship on the  // same layer, 0 ifthere is no design rule asking for  // min_spacing relationship  intm_spacing;  // the worst case value for dimension relationship on the // same layer, 0 if not applicable (minimum line width)  intm_dimension;  // the worst case value for neighbor_spacing relationshipon  // the same layer, 0 if not applicable  // (also called parallelspacing)  int m_neighbor_spacing;  // the worst case value forneighbor_within relationship on  // the same layer, 0 if not applicable int m_neighbor_within;  // the worst case value for neighbor_dimensionrelationship on  // the same layer  int m_neighbor_width;  int m_area;// minimum island area  int hole_area;  int m_common_run_length; std::map<layer_number, int> m_common_run_clearance_vector_map;  //extensions from this layer to other layers  std::map<layer_number, int>m_cover_layers;  // extensions from other layers to this layer std::map<layer_number, int> m_cut_layers;  // worst case differentlayer clearance, from this layer to other layers  std::map<layer_number,int> m_clearance_layers;  // for via rules  std::set<layer_number>m_overlap_layers;  std::set<layer_number> m_dual_cover_layers; };Design Rule Checking Flow

FIG. 3 is a flow chart of the overall system flow for real time visuallayout design rule checking. The reader will recognize that the flow canbe easily modified for use as a batch job instead. As with allflowcharts herein, it will be appreciated that many of the steps in FIG.3 can be combined, performed in parallel or performed in a differentsequence without affecting the functions achieved. In some cases are-arrangement of steps will achieve the same results only if certainother changes are made as well, and in other cases a re-arrangement ofsteps will achieve the same results only if certain conditions aresatisfied. However, as described in detail hereinafter, there arecertain steps which are performed prior to other steps, in order toobtain benefits of the invention.

In step 310, the relationship_master data set is built from a set ofdesign rules for the target fabrication process. This can be donemanually, or in some embodiments it can be automated. It is provided tothe DRC system either electronically or via a computer readable medium,and it is stored accessibly to the system on a computer readable medium.As used herein, a computer readable medium is one on which informationcan be stored and read by a computer system. Examples include a floppydisk, a hard disk drive, a RAM, a CD, a DVD, flash memory, a USB drive,and so on. The computer readable medium may store information in codedformats that are decoded for actual use in a particular data processingsystem. A single computer readable medium, as the term is used herein,may also include more than one physical item, such as a plurality of CDROMs or a plurality of segments of RAM, or a combination of severaldifferent kinds of media.

In step 312, the system displays on a monitor the layout or layoutregion selected by the user. As used herein, the term “region” refers toa portion as viewed from above, including whatever layers are pertinent.As a degenerate case, the entire layout is also a “region”. The user canmanipulate (edit) objects in the layout using familiar editing commands,such as keyboard- or mouse-based behaviors recognized by the system. Forexample, the user can select a group of objects by clicking and draggingthe mouse pointer to form a rectangle around them. The user can thenmove the objects as a group by clicking within the rectangle anddragging it. Editing commands are recognized by the operating system anddelivered to the application program by way of events in a well knownmanner. For example, user dragging of a group of objects might cause aseries of events to be delivered to the application program, one aftereach movement by some number of pixels, or some number of milliseconds.The application program receives these events and determines for itselfwhat the event represents. Step 312 can include a conventional eventloop, whereby the application program repeatedly checks for new events.When it receives an event, step 312 determines that it represents alayout editing command such as user dragging of a group of shapes acrossthe layout.

In step 314, the system collects all the editing shapes, which are theones that are being edited by the user. For a click-and-drag command,the editing shapes are the ones that are being moved to a differentposition in the layout. For a shape re-sizing command, the editing shapeis the one being resized.

In step 316, the system collects all the surrounding shapes, which in aclick-and-drag command, are the shapes near the new position of theediting shapes. A selection algorithm is used here which errs on theside of collecting more shapes than necessary, since while inclusion ofadditional shapes could impact performance, the exclusion of relevantshapes will impact accuracy. One efficient way to collect appropriateshapes is to create a bounding box around the editing shapes in theirnew position, then extend the box in all four directions by 1.5 timesthe worst case minimum spacing or the worst case minimum inter-layerclearance, whichever is larger. All shapes at least partiallyoverlapping with the expanded bounding box, in any layer, are thenincluded in the result. A conventional range search engine can be usedfor this step. Geometry processing is not needed.

In step 318, horizontal and vertical scan line trees sweep_x and sweep_yare built from all of the collected shapes, including both the editingshapes and the static shapes. The horizontal scan line tree sweep_x is amap of particular vertical scan lines, and will be scanned horizontallyacross the selected layout region, from left to right. The vertical scanline tree sweep_y is a map of particular horizontal scan lines, and willbe scanned vertically across the selected layout region, from bottom totop.

FIG. 4 is a flow chart of step 318, and as can be seen, it includes astep 410 of building sweep_x and another step 412 of building sweep_y.

FIG. 5 illustrates pertinent parts of the sweep_x data structure 510. Itcontains two tree data structures, called enter_tree 512 and exit_tree514. Enter-tree is a map of the vertical scan lines, and the verticalposition on such scan lines, of the left-hand endpoints of thehorizontal edges. Exit_tree is a map of the vertical scan lines, and thevertical position on such scan lines, of the right-hand endpoints of thehorizontal edges.

Map 516 is an expansion of exit_tree 514; enter_tree 512 has the samestructure and is therefore not shown in FIG. 5. It comprises key-valuepairs, in which all the keys indicate horizontal positions and all thevalues are structures of class ‘edge-tree’, and represent vertical scanlines. A “map” is a standard structure which allows only one entry foreach unique key. Thus exit_tree organizes all the vertical scan lines,and there is one vertical scan line for each horizontal positionincluded. Note that by representing only specific vertical scan lines,the horizontal scanning algorithm will be able to jump over allhorizontal positions that do not contain any corners.

Multimap 518 is an expansion of one of the edge_tree structures 520. Theother edge_trees have the same structure and therefore are not shown inFIG. 5. Edge_tree 520 also comprises key-value pairs, except that as a“multimap”, multiple entries are allowed having the same key. Inedge_tree 520 the keys indicate vertical positions, and all the valuesare structures of class ‘edge’, representing an edge having an endpointon the current vertical scan line. Since this is part of the exit_tree514, only those horizontal edges having right-hand endpoints at thishorizontal position are included in edge_tree 520. (In the enter_tree512, only edges having left-hand endpoints at a given horizontalposition are included in the edge_tree for the vertical scan line at thegiven horizontal position.) A multimap is used here rather than a map,in order to accommodate multiple edges having a right-hand endpoint atthe same x and y position in the layout region. Multiple edges arepossible because some could be on different layers in the layout, orsome could even be superimposed on each other in a single layer.

Block 522 is an expansion of one of the edge structures 524. The otheredges have the same structure and therefore are not shown in FIG. 5.Edge 524 contains information about a particular horizontal edge of oneof the shapes in the layout region, and also acts as a holding area forcertain information developed during the scan as described hereinafter.At least the following information is included:

-   -   edge ID: an identifying value for the edge;    -   layer ID: an indication of the layer number on which the edge        lies;    -   edge start (x,y): the x and y coordinates of the left-hand        endpoint of the edge;    -   edge end (x,y): the x and y coordinates of the right-hand        endpoint of the edge;    -   edge against scan line? (T/F): a Boolean indicating whether the        edge is the bottom edge of a shape (True if it is a bottom edge,        False otherwise);    -   quadrant depth vector: four slots indicating how many shapes        overlap each other in the current layer at the right-hand        endpoint of the edge (for exiting edges) or the left-hand        endpoint (for entering edges) or the intersection point of the        edge and the vertical scan line (for all other edges in the        current scan line), in each of the four quadrants centered at        that point (for an embodiment that supports 45 degree        geometries, this is an octant depth vector containing eight        slots);    -   neighbor map: a map of neighboring edges

FIG. 6 illustrates pertinent parts of the sweep_y data structure 610.Like sweep_x, sweep_y contains two tree data structures, calledenter_tree 612 and exit_tree 614. In sweep_y, enter-tree is a map of thehorizontal scan lines, and the horizontal position on such scan lines,of the lower endpoints of the vertical edges. Exit_tree is a map of thehorizontal scan lines, and the horizontal position on such scan lines,of the upper endpoints of the vertical edges.

Map 616 is an expansion of exit_tree 614; enter_tree 612 has the samestructure and is therefore not shown in FIG. 6. It comprises key-valuepairs, in which all the keys indicate vertical positions and all thevalues are structures of class ‘edge-tree’, and represent horizontalscan lines. Thus exit_tree organizes all the vertical scan lines, andsince exit_tree is a map, there is only one horizontal scan line foreach vertical position included. Note that by representing only specifichorizontal scan lines, the vertical scanning algorithm, like thehorizontal scanning algorithm, will be able to jump over all verticalpositions that do not contain any corners.

Multimap 618 is an expansion of one of the edge_tree structures 620. Theother edge_trees have the same structure and therefore are not shown inFIG. 6. Edge_tree 620 also comprises key-value pairs, except that as a“multimap”, multiple entries are allowed having the same key. Inedge_tree 620 the keys indicate horizontal positions, and all the valuesare structures of class ‘edge’, representing an edge having an endpointon the current horizontal scan line. Since this is part of the exit_tree614, only those horizontal edges having upper endpoints at this verticalposition are included in edge_tree 620. (In the enter_tree 612, onlyedges having lower endpoints at a given vertical position are includedin the edge_tree for the horizontal scan line at the given verticalposition.)

Block 622 is an expansion of one of the edge structures 624. The otheredges have the same structure and therefore are not shown in FIG. 6.Edge 624 contains information about a particular vertical edge of one ofthe shapes in the layout region, and also acts as a holding area forcertain information developed during the scan as described hereinafter.At least the following information is included:

-   -   edge ID: an identifying value for the edge;    -   layer ID: an indication of the layer number on which the edge        lies;    -   edge start (x,y): the x and y coordinates of the lower endpoint        of the edge;    -   edge end (x,y): the x and y coordinates of the upper endpoint of        the edge;    -   edge against scan line? (T/F): a Boolean indicating whether the        edge is the left edge of a shape (it will be True if it is a        left edge, False otherwise);    -   quadrant depth vector: four slots indicating how many shapes        overlap each other in the current layer at the lower endpoint of        the edge (for exiting edges) or the upper endpoint (for entering        edges) or the intersection point of the edge and the horizontal        scan line (for all other edges in the current scan line), in        each of the four quadrants centered at that point (for an        embodiment that supports 45 degree geometries, this is an octant        depth vector containing eight slots);    -   neighbor map: a map of neighboring edges

As can be seen, sweep_x contains only horizontal edges and sweep_ycontains only vertical edges. Thus the scan lines in each data structureare perpendicular to the edges that will be encountered during atraversal of the structure. In an embodiment supporting diagonal edgesas well, two more sweep data structures are present as well: onecontaining scan lines oriented parallel to one diagonal and the othercontaining scan lines oriented parallel to the other diagonal. Each datastructure includes only edges oriented perpendicularly to its scanlines, so again, a scan line sweep of the scan lines in each structurewill encounter only those edges oriented perpendicularly to the scanline.

FIG. 7 is a flow chart detail of a method 410 for building thehorizontal scan line tree sweep_x. In step 710, a list is formed of allthe horizontal edges of all shapes in the selected region, includingediting shapes. In step 712, the list is sorted by the horizontalposition of all the left-hand endpoints of the edges. There may bemultiple edges whose left-hand endpoints have the same horizontalposition, and these would be grouped together in the sort.

In step 714, enter_tree is created for sweep_x. This is accomplished by,at each unique horizontal position represented in the sorted list (step716), creating a scan line multimap (of class ‘edge_tree’) for avertical scan line at that horizontal position (step 718). In step 720,the scan line multimap at that horizontal position is populated with allthe edges (structures of class ‘edge’) in the list having left-handendpoints at the current horizontal position.

After enter_tree has been created and populated for sweep_x, the listfrom step 710 is re-sorted by horizontal position of all the right-handendpoints of the edges. Again, there may be multiple edges whoseright-hand endpoints have the same horizontal position. In step 724,exit_tree is created for sweep_x. Similarly to the creation ofenter_tree, this is accomplished by, at each unique horizontal positionrepresented in the sorted list (step 726), creating a scan line multimap(of class ‘edge_tree’) for a vertical scan line at that horizontalposition (step 718). In step 720, the scan line multimap at thathorizontal position is populated with all the edges (structures of class‘edge’) in the list having right-hand endpoints at the currenthorizontal position.

FIG. 8 is a flow chart detail of a method 412 for building thehorizontal scan line tree sweep_y. In step 810, a list is formed of allthe vertical edges of all shapes in the selected region, includingediting shapes. In step 812, the list is sorted by the vertical positionof all the lower endpoints of the edges. Again, there may be multipleedges whose lower endpoints have the same vertical position, and thesewould be grouped together in the sort.

In step 814, enter_tree is created for sweep_y. This is accomplished by,at each unique vertical position represented in the sorted list (step812), creating a scan line multimap (of class ‘edge_tree’) for ahorizontal scan line at that vertical position (step 818). In step 820,the scan line multimap at that vertical position is populated with allthe edges (structures of class ‘edge’) in the list having lowerendpoints at the current vertical position.

After enter_tree has been created and populated for sweep_y, the listfrom step 810 is re-sorted by horizontal position of all the upperendpoints of the edges. Again, there may be multiple edges whose upperendpoints have the same vertical position. In step 824, exit_tree iscreated for sweep_y. As before, this is accomplished by, at each uniquevertical position represented in the sorted list (step 822), creating ascan line multimap (of class ‘edge_tree’) for a horizontal scan line atthat vertical position (step 818). In step 820, the scan line multimapat that vertical position is populated with all the edges (structures ofclass ‘edge’) in the list having upper endpoints at the current verticalposition.

Returning now to FIG. 3, after the horizontal and vertical scan linetrees have been built (step 318), all of the required topographicalrelationships among the shapes in the layout region are now extracted(step 320).

FIG. 9 is a flow chart of step 320, and as can be seen, it includes astep 910 of scanning the horizontal scan tree sweep_x and another step912 of scanning the vertical scan tree sweep_y. Note that in anotherembodiment the vertical scan can be performed first and the horizontalscan thereafter. In yet another embodiment, the two scans can beperformed in an alternating manner. In a particularly advantageousembodiment, since the two scans are independent of each other, anddiscover different items of information for populating the corner datastructures, the two scans are performed simultaneously on two differentprocessor cores. In yet another embodiment, the two scans arecoordinated with each other so that they proceed from corner to corner,with all data for a given corner populated before jumping to the nextcorner. As used herein, the two scans are said to be performed“concurrently” with each other if they overlap in time in such a waythat corner data is extracted from at least one endpoint of at least onehorizontal edge before corner data is extracted from at least oneendpoint of at least one vertical edge, and corner data is extractedfrom at least one endpoint of at least one vertical edge before cornerdata is extracted from at least one endpoint of at least one horizontaledge.

FIG. 10 is a flow chart of step 910, for scanning the horizontal scantree sweep_x. In step 1008, the vertical scan line edge-tree multimapobject current_scan_line is created. In step 1010, current_scan_linetraverses both enter_tree and the exit_tree together so that thevertical scan lines from both trees are considered in monotonicallyvarying sequence, left to right. Since these two trees contain onlythose vertical scan lines on which an endpoint of a horizontal edgelies, intervening vertical scan lines are skipped during this scan. Thecurrent vertical scan line is maintained in a multimap object of classedge_tree, having the structure of edge_tree 520 (FIG. 5). It has acurrent horizontal scanning position, and stores the information shownin block 522 for each horizontal edge that intersects a vertical line atthe current horizontal scanning position.

In step 1012, current_scan_line is updated by adding all horizontaledges having a left-hand endpoint located at the current horizontal scanposition. In step 1014, the quadrant depth vector (FIG. 5) for each edgein the current vertical scan line multimap is updated. In order toillustrate this step, reference is made to FIGS. 11A and 11B, whichillustrate simple portions of a layout. FIG. 11A highlights a convexcorner 1114, whereas FIG. 11B highlights a concave corner 1134. In FIG.11A, 1110 is the current vertical scan line and 1112 is a particularedge being considered. Edge 1112 is represented in the enter_tree and incurrent_scan_line, and has a left-hand endpoint 1114 located on verticalscan line 1110. Edge 1112 also forms the upper edge of a rectangle 1116.Four other rectangles are also shown in the figure, 1118, 1120, 1122 and1124. Four quadrants, centered at endpoint 1114 and numbered I, II, IIIand IV for purposes of the present discussion, are also shown in FIG.11A. Similarly, in FIG. 11B, 1130 is the current vertical scan line and1132 is a particular edge being considered. Edge 1132 is represented inthe enter_tree, and has a left-hand endpoint 1134 located on verticalscan line 1110. Edge 1132 also forms the upper edge of a rectangle 1136.Four other rectangles are also shown in the figure, 1138, 1140, 1142 and1144. The four quadrants I, II, III and IV, centered at endpoint 1134,are also shown in FIG. 11B.

The quadrant depth vector indicates the number of shapes in a particularlayer that border a particular edge endpoint in each of the fourquadrants centered at that endpoint. In FIG. 11A, quadrants I, II andIII contain no shapes that border endpoint 1114, and quadrant IVcontains one such shape 1116. Thus the quadrant depth vector at endpoint1114 is (0, 0, 0, 1). On the other hand, in FIG. 11B, quadrant IIcontains no shapes that border endpoint 1134, whereas quadrants I, IIIand IV each contain one such shape. Thus the quadrant depth vector atendpoint 1134 is (1, 0, 1, 1). It can be seen that if exactly onequadrant depth is zero, then the point represents a concave corner of anisland, as in FIG. 11B. If exactly two values are zero, and they are inadjacent quadrants, then the endpoint is not on a corner of an island.If the two zeros are in diagonally opposite quadrants, then the endpointis a corner of two diagonally adjacent islands, sharing the one corner.If exactly three values are zero, as in FIG. 11A, then the endpointrepresents a convex corner of an island, island 1116 in FIG. 11A. Ifnone of the values are zero, then the endpoint is inside an island anddoes not represent a corner of an island. The quadrant depth vector isused in later steps, as described hereinafter.

In step 1014, the updating of the quadrant depth vector for an edge inthe enter_tree (i.e. an edge whose left-hand endpoint lies on thecurrent vertical scan line), involves incrementing the value for eitherquadrant I or quadrant IV by one. The value for quadrant I isincremented if the “edge against scan line?” Boolean for the edge 1112indicates True (i.e. the edge is the bottom edge of a shape), or thevalue for quadrant IV is incremented if the “edge against scan line?”Boolean for the edge 1112 indicates False (i.e. the edge is the top edgeof a shape). Similarly, the updating of the quadrant depth vector for anedge in the exit_tree (i.e. an edge whose right-hand endpoint lies onthe current vertical scan line), involves decrementing the value foreither quadrant I or quadrant IV by one. The value for quadrant I isdecremented if the “edge against scan line?” Boolean for the exitingedge indicates True (i.e. the edge is the bottom edge of a shape), orthe value for quadrant IV is decremented if the “edge against scanline?” Boolean for the exiting edge indicates False (i.e. the edge isthe top edge of a shape). It can be seen that the quadrant depth vectorincrements quantities as the vertical scan line encounters shapes whilemoving left-to-right across the region. It decrements quantities as thescan line moves past shapes.

In step 1016, each of the edges whose left-hand endpoint lies on thecurrent scan line are processed. These are the edges represented inenter_tree. As they are processed, a “corner” data structure for theendpoint is populated. The corner data structure stores the informationillustrated in FIGS. 11A and 11B, and can be described in a C++ likepseudocode class definition as follows:

class corner {  edge* m_origin_x; // ori_x vertical edge meeting at thecorner. Of the edge endpoints, only the x- coordinates are populated. edge* m_origin_y; // ori_y horizontal edge meeting at the corner. Ofthe edge endpoints, only the y- coordinates are populated.  edge*m_target_x; // tar_x nearest vertical edge, walking horizontally alongshape contour from corner  edge* m_target_y; // tar_y nearest horizontaledge, walking vertically along shape contour from corner  edge*m_space_ray_x; // s_ray_x nearest vertical facing edge, walkinghorizontally from corner, away from shape  edge* m_space_ray_y; //s_ray_y nearest horizontal facing edge, walking vertically from corner,away from shape  edge* m_dimension_ray_x; // d_ray_x last vertical edgewalking horizontally into shape, before exiting shape  edge*m_dimension_ray_y; // d_ray y last horizontal edge walking verticallyinto shape, before exiting shape  std::list<corner*> m_neighbor_list; //list of nearest neighbor corners  bool m_is_convex; // whether thecorner is convex or concave  ray* create_space_ray_x( ) {   ray* p_ray =new ray(this); // the first point is the corner position, i.e., the tailof the arrow   p_ray->m_p1.x = m_origin_x->m_point1.x;   p_ray->m_p1.y =m_origin_y->m_point1.y; // the second point is the x position of them_space_ray_x, i.e., the head of the arrow   p_ray->m_p2.x =m_space_ray_x->m_point1.x;   p_ray->m_p2.y = m_origin_y->m_point1.y;  return p_ray;  };  ray* create_space_ray_y( ) {   ray* p_ray = newray(this); // the first point is the corner position, i.e., the tail ofthe arrow   p_ray->m_p1.x = m_origin_x->m_point1.x;   p_ray->m_p1.y =m_origin_y->m_point1.y; // the second point is the y position of them_space_ray_y, i.e., the head of the arrow   p_ray->m_p2.x =m_origin_x->m_point1.x;   p_ray->m_p2.y = m_space_ray_y->m_point1.y;  return p_ray;  };  ray* create_dimension_ray_x( ) {   ray* p_ray = newray(this); // the first point is the corner position, i.e., the tail ofthe arrow   p_ray->m_p1.x = m_origin_x->m_point1.x;   p_ray->m_p1.y =m_origin_y->m_point1.y; // the second point is the x position of them_dimension_ray_x, i.e., the head of the arrow   p_ray->m_p2.x = m_spacedimension_x->m_point1.x;   p_ray->m_p2.y = m_origin_y->m_point1.y;  return p_ray;  };  ray* create_dimension_ray_y( ) {   ray* p_ray = newray(this); // the first point is the corner position, i.e., the tail ofthe arrow   p_ray->m_p1.x = m_origin_x->m_point1.x;   p_ray->m_p1.y =m_origin_y->m_point1.y; // the second point is the y position of them_dimension_ray_y, i.e., the head of the arrow   p_ray->m_p2.x =m_origin_x->m_point1.x;   p_ray->m_p2.y =m_space_dimension_y->m_point1.y;   return p_ray;  }; };

A ray object represents essentially an arrow with a head point and tailpoint. All the tail points coincide with the current corner. ForManhattan layouts the rays are either horizontal or vertical, though in45 degree layouts it can also have either of the two diagonalorientations. The ‘ray’ class is described in a C++ like pseudocodeclass definition as follows:

  class ray {  corner* m_parent_corner;  bool is_s_ray;  point m_p1; point m_p2; }

The corner data structures developed during the scan are maintained asentries in a synchronized_corner_map structure. This structure is a map,in which the keys identify a layer number and an x and y position onthat layer, and the values are objects of class ‘corner’.

FIG. 12 is a flow chart detail of step 1016, for processing the enteringedges. In step 1210, each of the entering edges represented in thecurrent vertical scan line are considered. In FIG. 11A, this will beonly edge 1112. In FIG. 11B, this will be edge 1132, as well as the topand bottom edges of rectangle 1138. In step 1214, it is determinedwhether the left-hand endpoint of the current edge is a corner of anisland. This is determined by reference to the current quadrant vector,as described previously. If it is not a corner of an island, then theedge is skipped.

In step 1216, a corner data structure for the left-hand endpoint of thecurrent edge is instantiated in synchronized_corner_map if it does notalready exist. The corner data structure might already exist insynchronized_corner_map if, for example, the corner had already beenencountered because of a different horizontal edge on the same layerthat starts at the same point (such as the bottom edge of rectangle 1138in FIG. 11B), or as part of the vertical scan in an embodiment in whichthe vertical scan precedes or operates concurrently with the horizontalscan. In step 1218, the system walks upward and downward along thecurrent vertical scan line from the current horizontal edge, populatingthe available corner information as it is learned. In particular,referring to the corner data structure definition above and theillustrations in FIGS. 11A and 11B, the edges s_ray_y, tar_y andd_ray_y, as well as any others required by the design rules, arepopulated. Note that these values identify the shape edges at the headof the respective ray. The ray itself is identified separately in thecorner data structure, as previously mentioned.

In one embodiment, all design rule checks are performed only after allscans are complete. However, the present embodiment incorporates afeature in which the system performs certain simple edge-based rulechecks as part of step 1218. For example, if the current edge is a topedge and the walk upwards along the current vertical scan line meets thebottom edge of a shape in the same layer, then s_ray_y is populated inthe corner data structure and the minimum spacing rule is checked aswell. This check involves comparing the length of s_ray_y with theminimum spacing value in the relationship_master. If the current edge isa top edge and the walk upwards along the current vertical scan linemeets the top edge of a shape in a different layer, then the minimumextension rule is checked by comparing the distance walked to theminimum extension value for the appropriate layer pair in therelationship_master. If the current edge is a bottom edge and the walkupwards along the current vertical scan line meets the top edge of ashape in the same layer, then d_ray_y is populated, and also the minimumdimension rule is checked. This check involves comparing the value ofd_ray_y with the minimum dimension value in the relationship_master. Ifthe current edge is a bottom edge and the walk upwards along the currentvertical scan line meets the top edge of a shape in a different layer,then the minimum overlap rule is checked. Similar checks are performedduring the walk downward from the current edge. If during the walks upand down the current vertical scan line, the distance walked exceeds theworst case limit from the relationship_master, there is no design ruleviolation encountered and it is not necessary to populate further itemsin the corner data structure that would be encountered in the currentwalking direction.

After the available corner structure information items have beenpopulated, then the system returns to step 1210 to consider the nextentering edge in the current vertical scan line.

FIG. 13 is a flow chart detail of step 1018 for processing exiting edgecorners. In step 1310, each of the exiting edges represented in thecurrent vertical scan line are considered. In step 1314, it isdetermined whether the right-hand endpoint of the current edge is acorner of an island. This is determined by reference to the currentquadrant vector, as described previously. If it is not a corner of anisland, then the edge is skipped.

In step 1316, a corner data structure for the right-hand endpoint of thecurrent edge is instantiated in synchronized_corner_map if it does notalready exist. Again, the corner data structure might already exist insynchronized_corner_map if, for example, the corner had already beenencountered because of a different horizontal edge on the same layerthat ends at the same point, or as part of the vertical scan in anembodiment in which the vertical scan precedes or operates concurrentlywith the horizontal scan. In step 1318, the system walks upward anddownward along the current vertical scan line from the currenthorizontal edge, populating the available corner information as it islearned. In particular, referring to the corner data structuredefinition above and the illustration in FIGS. 11A and 11B, the edgess_ray_y, tar_y and d_ray_y, as well as any others required by the designrules, are populated.

In addition, preferably but not essentially, the system also in step1318 performs the same edge-based rule checks for the exiting edges asperformed and described above with respect to step 1218 for enteringedges.

After the available corner structure information items have beenpopulated, then the system returns to step 1310 to consider the nextexiting edge in the current vertical scan line.

Returning to FIG. 10, after both the entering and exiting edges havingan endpoint on the current vertical scan line are processed, the systempopulates or updates information about islands (step 1020). Islands arerepresented in objects of class ‘island’, and maintained in a map ofclass ‘island_map’. They are instantiated as the vertical scan lineencounters them as it scans horizontally, and are updated as thevertical scan line moves across them horizontally, corner to corner.Pertinent parts of the ‘island’ data structure are described in a C++like pseudocode class definition as follows:

class island {  // For horizontal scan, this is the iterator in  //current_scan_line of the bottom_most_edge of the island edge_tree::iterator m_start_iterator;  // For horizontal scan, this isthe iterator in  // current_scan_line of the top_most_edge of the island edge_tree::iterator m_end_iterator;  // the unique id of the island. // Islands are split or merged during the horizontal scan.  // When anisland is split, the island id is not split  // (i.e., multiple islandswill share same id), so we know  // these islands are actuallysub-islands of a larger island;  // When multiple islands mergetogether, the smallest island  // id is used as the shared id for allthe islands merged together.  int m_island_id;  // accumulating thecommon run length against the same layer.  // For efficiency, 2D spacingrules are checked during scan,  // not after. In another embodiment theycould be checked afterwards.  int m_last_valid_common_run_position;  //accumulating the common run length against different layers std::map<layer_number, int> m_last_valid_top_position_vector; std::map<layer_number, int> m_last_valid_bottom_position_vector;  //accumulating the area of this island so far  int m_area;  //accumulating the area of the potential hole right above this island. int m_hole_area;  // Horizontal position that current_scan_line stoppedlast time  int m_last_position_updated; };

Among other things, the island data structure accumulates the followinginformation about a particular island during the process of thehorizontal scan: area of the island, area of a hole just above theisland, common run lengths against other islands in the same layer andislands in other layers. For clarity of illustration, the presentdescription will concentrate primarily on the island area as an exampleof island-based rule checking Reference will be made to FIG. 19E, whichillustrates a sample layout region having three overlapping rectangles1932, 1934 and 1936, all on a single layer. Because they overlap on asingle layer, they form a single island 1930.

Roughly described, island area is accumulated during the horizontal scanby using the shape corners to divide the island into non-overlapping“island rectangles”, the area of which are easily determined from thehorizontal edges represented in the current vertical scan line. In theexample of FIG. 19E, the method divides the island 1930 into five islandrectangles bounded horizontally by the broken vertical lines 1938. Likefor the extraction of corner data, the updating of island data takesplace only at those vertical scan lines containing a corner of theisland. Horizontal scanning does not stop anywhere between corners. Arectangle (not shown) disposed entirely within rectangle 1932, forexample, will not bear on any island design rule and does not become astopping place during the scan. A high level description of the processis illustrated in the flow chart of FIG. 23.

Referring to FIG. 23, as mentioned, the islands are stored in a mapcalled island_map. The keys of island_map identify the lower left cornerof a respective island. In step 2310, each island having a corner lyingon the current vertical scan line is considered. In step 2312, if thecorner represents an island being encountered for the first time duringthe scan, a new island data structure is instantiated in island_map(step 2314). The area is set to zero (step 2316), and in step 2324, thevalue of m_last_position updated for the new island is set equal to thex-position of the current vertical scan line.

If the current island is already represented in island_map, theneffectively a vertical slice is made through the current island at thecurrent vertical scan line; and the area of the left-adjacent rectangleis added to the area being accumulated. Accordingly, in step 2318, theheight H of the left-adjacent rectangle is calculated as the distancealong the current vertical scan line from the bottom edge of the currentisland to the top edge of the current island. This information isavailable in current_scan_line, because at least one of the top andbottom edges is a corner, and the y-position of the corner is availableas the left- or right-hand endpoint of a horizontal edge in the currentvertical scan line. The other of the top and bottom edges may also be acorner, or may be an edge that merely intersects the current verticalscan line. In either case its y-position is available as well incurrent_scan_line. In step 2320, the width W of the left-adjacentrectangle is calculated as the horizontal position of the current scanline minus the last scan line position at which island information wasupdated, which is the value in m_last_position updated. In step 2322 theproduct of H and W is added to the area value for the current island.

In step 2324, as mentioned above, the value of m_last_position updatedfor the new island is set equal to the x-position of the currentvertical scan line. The method then returns to step 2310 forconsideration of the next island having a corner on the current verticalscan line.

Once all islands having a corner on the current vertical scan line havebeen considered, then any two or more of such islands that are nowvertically-adjacent are merged into a single island in step 2326 andtheir area values summed. In step 2328, any island that is now splitinto two, perhaps separated vertically by a newly encountered hole ornotch, are split. The details of the merging and splitting operationsare not important for an understanding of the invention. Note thatwhereas island area information is captured during the horizontal scan,it is not compared to the design rule values in the present embodimentuntil later.

Returning to FIG. 10, after the island data has been updated based onthe current scan line, in step 1022, as a time saving technique, thequadrant depth vectors for each of the entering horizontal edges in thecurrent vertical scan line are copied from the right-hand quadrants tothe corresponding left-hand quadrants. In this manner the left-handquadrant depth values can be incremented or decremented as the verticalscan line moves rightward, and will contain accurate values when thescan line reaches the right hand endpoint of the edge. In step 1024, allthe exiting edges are removed from the current vertical scan line. Theroutine then returns to step 1010 for the next horizontal scan position.

Returning to FIG. 9, after the horizontal scan tree has been scanned,the vertical scan tree is scanned (step 912). FIG. 14 is a flow chart ofstep 912, for scanning the vertical scan tree sweep_y

FIG. 14 is a flow chart of step 912, for scanning the vertical scan treesweep_y. In step 1408, the horizontal scan line edge-tree multimapobject current_scan_line is created. In step 1410, current_scan_linetraverses both enter_tree and the exit_tree together so that thehorizontal scan lines from both trees are considered in monotonicallyvarying sequence, bottom to top. Since these two trees contain onlythose horizontal scan lines on which an endpoint of a vertical edgelies, intervening horizontal scan lines are skipped during this scan.The current horizontal scan line is maintained in a multimap object ofclass edge_tree, having the structure of edge_tree 620 (FIG. 6). It hasa current horizontal scanning position, and stores the information shownin block 622 for each vertical edge that intersects a horizontal line atthe current vertical scanning position.

In step 1412, current_scan_line is updated by adding all vertical edgeshaving a lower endpoint located at the current horizontal scan position.In step 1414, the quadrant depth vector (FIG. 6) for each edge in thecurrent horizontal scan line multimap is updated. This step involves,for an edge in the enter_tree (i.e. a vertical edge whose lower endpointlies on the current horizontal scan line), incrementing the value foreither quadrant I or quadrant II by one. The value for quadrant I isincremented if the “edge against scan line?” Boolean for the edge 1112indicates True (i.e. the edge is the left-hand edge of a shape), or thevalue for quadrant II is incremented if the “edge against scan line?”Boolean for the edge 1112 indicates False (i.e. the edge is theright-hand edge of a shape). Similarly, the updating of the quadrantdepth vector for an edge in the exit_tree (i.e. an edge whose upperendpoint lies on the current horizontal scan line), involvesdecrementing the value for either quadrant I or quadrant II by one. Thevalue for quadrant I is decremented if the “edge against scan line?”Boolean for the exiting edge indicates True (i.e. the edge is theleft-hand edge of a shape), or the value for quadrant II is decrementedif the “edge against scan line?” Boolean for the exiting edge indicatesFalse (i.e. the edge is the right-hand edge of a shape). It can be seenthat the quadrant depth vector increments quantities as the horizontalscan line encounters shapes while moving upward across the region. Itdecrements quantities as the scan line moves past shapes.

In step 1416, each of the edges whose lower endpoint lies on the currentscan line are processed. These are the edges represented in enter_tree.As they are processed, the “corner” data structure for the endpoint ispopulated. in synchronized_corner_map. As mentioned, the relevant cornerdata structure may already exist from a previously encountered differentvertical edge on the same layer that starts at the same point, or aspart of the horizontal scan in an embodiment in which the horizontalvertical scan precedes or operates concurrently with the vertical scan.

FIG. 15 is a flow chart detail of step 1416, for processing the enteringedges. In step 1510, each of the entering edges represented in thecurrent horizontal scan line are considered. In step 1514, it isdetermined whether the lower endpoint of the current edge is a corner ofan island. This is determined by reference to the current quadrantvector, as described previously. If it is not a corner of an island,then the edge is skipped.

In step 1516, a corner data structure for the left-hand endpoint of thecurrent edge is instantiated in synchronized_corner_map if it does notalready exist. In step 1518, the system walks leftward and rightwardalong the current horizontal scan line from the current vertical edge,populating the available corner information as it is learned. Inparticular, referring to the corner data structure definition above andthe illustrations in FIGS. 11A and 11B, the edges s_ray_x, tar_x andd_ray_x, as well as any others required by the design rules, arepopulated.

In an embodiment, certain edge-based rule checks are also performed aspart of step 1518, similar to those performed in step 1218. For example,if the current edge is a right-hand edge and the walk rightward alongthe current horizontal scan line meets the left-hand edge of a shape inthe same layer, then s_ray_x is populated in the corner data structureand the minimum spacing rule is checked as well. This check involvescomparing the length of s_ray_x with the minimum spacing value in therelationship_master. If the current edge is a right-hand edge and thewalk rightwards along the current horizontal scan line meets theright-hand edge of a shape in a different layer, then the minimumextension rule is checked by comparing the distance walked to theminimum extension value for the appropriate layer pair in therelationship_master. If the current edge is a left-hand edge and thewalk rightwards along the current horizontal scan line meets theright-hand edge of a shape in the same layer, then d_ray_x is populated,and also the minimum dimension rule is checked. This check involvescomparing the value of d_ray_x with the minimum dimension value in therelationship_master. If the current edge is a left-hand edge and thewalk rightwards along the current horizontal scan line meets theright-hand edge of a shape in a different layer, then the minimumoverlap rule is checked. Similar checks are performed during the walkleftward from the current edge. If during the walks leftward andrightward along the current horizontal scan line, the distance walkedexceeds the worst case limit from the relationship_master, there is nodesign rule violation encountered and it is not necessary to populatefurther items in the corner data structure that would be encountered inthe current walking direction.

After the available corner structure information items have beenpopulated, then the system returns to step 1510 to consider the nextentering edge in the current horizontal scan line.

FIG. 16 is a flow chart detail of step 1418 for processing exiting edgecorners. In step 1610, each of the exiting edges represented in thecurrent horizontal scan line are considered. In step 1614, it isdetermined whether the upper endpoint of the current edge is a corner ofan island. This is determined by reference to the current quadrantvector, as described previously. If it is not a corner of an island,then the edge is skipped.

In step 1616, a corner data structure for the upper endpoint of thecurrent edge is instantiated in synchronized_corner_map if it does notalready exist. Again, the corner data structure might already exist insynchronized_corner_map. In step 1618, the system walks leftward andrightward along the current horizontal scan line from the currentvertical edge, populating the available corner information as it islearned. In particular, referring to the corner data structuredefinition above and the illustration in FIGS. 11A and 11B, the edgess_ray_x, tar_x and d_ray_x, as well as any others required by the designrules, are populated.

In addition, preferably but not essentially, the system also in step1618 performs similar edge-based rule checks for the exiting edges asperformed and described above with respect to step 1318.

After the available corner structure information items have beenpopulated, then the system returns to step 1610 to consider the nextexiting edge in the current horizontal scan line.

Returning to FIG. 14, after both the entering and exiting edges havingan endpoint on the current horizontal scan line are processed, it is notnecessary to populate or update information about islands. This was doneduring the horizontal scan (step 1020 in FIG. 10), and no additionalinformation will be determined during the vertical scan. For example,the area of an island, determined as a vertical scan line scans acrossthe island horizontally, will not be any different than the areadetermined as a horizontal scan line scans across the island vertically.

In step 1422, as a time saving technique, the quadrant depth vectors foreach of the entering vertical edges in the current horizontal scan lineare copied from the upper quadrants to the corresponding lowerquadrants. In this manner the lower quadrant depth values can beincremented or decremented as the horizontal scan line moves upward, andwill contain accurate values when the scan line reaches the upperendpoint of the edge. In step 1424, all the exiting edges are removedfrom the current horizontal scan line. The routine then returns to step1410 for the next vertical scan position.

Returning to FIG. 3, after step 320, all the topographical relationshipsneeded to perform the checks in the design rule set have been collectedinto a layout topology database. As mentioned, the term ‘database’ asused herein does not imply any unity or regularity of structure, and inthe present embodiment the layout topology database includessynchronized_corner_map, island_map and via_map, and other collectionsof data as well. In step 322, the values in the layout topology databaseare compared to those in the relationship master, in order to check allthe design rules. In one embodiment, all design rule violations arereported, whereas in another embodiment, only those violations involvingediting shapes are reported.

FIG. 17 is a flow chart detail of step 322. These are illustrativeexamples of design rules that are checked in the present embodiment onlyafter the scans across the layout region have been completed. Thegrouping of these checks as shown in FIG. 17 is only for convenience ofthe present description; it may or may not correspond to any grouping inany particular embodiment. For purposes of the present description, thedesign rules that are checked in FIG. 17 are grouped as follows.Corner-to-corner rules are checked in step 1710, and other corner-basedrules are checked in step 1712. Island-based rules are checked in step1714, and other rules (such as via-based rules) are checked in step1716. Details are provided herein regarding some of the corner-to-cornerrules, some other corner-based rules, and some island-based rules.

FIG. 18 is a flow chart detail of step 1710, for checking thecorner-to-corner rules. In step 1810, the system builds a map of spaceand dimension rays from the ray information previously populated intothe synchronized corner map. Rays from all layers are included, but onlythose space_rays that extend from convex corners, and only thosedimension_rays that extend from concave corners, are included in thisray map. In addition, instead of the rays representing the shape edgesencountered when walking away from the corner, the rays in the ray mapformed in step 1810 represent true rays from the corner to theencountered edge.

In step 1812, the ray map is scanned left-to-right to identifyintersections of the rays. A conventional scan line algorithm can beused for this purpose.

In step 1814, it is determined whether the current ray intersection isan intersection of two space_rays. The two corners from which thesespace_rays extend both have to be convex, so the situation is asillustrated in FIG. 19A, where s_rays 1910 and 1912 intersect. In thiscase the corner-to-corner Euclidean spacing 1914 is calculated. If thetwo shapes are located on the same layer, the spacing 1914 is comparedto the minimum corner-to-corner spacing value in relationship_master. Ifthey are on different layers, it is compared to the minimumcorner-to-corner clearance in relationship_master (step 1816).

If the intersecting rays are not both space_rays, then in step 1818 itis determined whether they are both dimension_rays in the same layer.The two corners from which these dimension_rays extend both have to beconcave, so the situation is as illustrated in FIG. 19B, where d_rays1916 and 1918 intersect. In this case the corner-to-corner Euclideandimension 1920 is again calculated and compared to the minimum dimensionrule value in relationship_master (step 1820).

If the intersecting rays are not both dimension_rays, then in step 1822it is determined whether one is a space_ray on one layer, and the otheris a dimension_ray on a different layer. Since the corner from which thespace_ray extends is convex, and the corner from which the dimension_rayextends in concave, the situation is as illustrated in FIG. 19C. In thisfigure, s_ray 1922 from a corner of shape 1921 intersects d_ray 1924from a corner of shape 1923, and the two shapes are on different layers.In this case the distance that the shape on one layer extends past theedge of the shape the other layer is calculated in both dimensions, andcompared to the minExtension or minDualExtension value inrelationship_master (step 1824).

Various other corner-based design rule checks can be performed withinthis loop as well, not shown in FIG. 18. The routine then loops back tostep 1812 to continue scanning for more intersecting rays.

FIG. 20 is a flow chart detail of step 1712, for checking certain othercorner-based rules. These rules are checked inside a loop 2010 whichtraverses the synchronized_corner_map. In step 2012, the edge lengthrule is checked from the current corner. For the horizontal edge meetingat this corner, this involves subtracting the x-position of the corner(ori_x) from the x-position of the nearest vertical edge, walkinghorizontally along the shape contour (tar_x) and comparing the absolutevalue of the difference to the minimum edge length value in therelationship_master. For the vertical edge meeting at this corner, thisinvolves subtracting the y-position of the corner (ori_y) from they-position of the nearest horizontal edge, walking vertically along theshape contour (tar_y) and comparing the absolute value of the differenceto the minimum edge length value in the relationship_master.

In step 2014, it is determined whether the current corner is concave orconvex. If it is concave, then in step 2016 the concave corner edgelength rule is checked. This rule requires that at least one of the twoadjacent edges forming a concave corner have at least a minimum length.This test can be performed using the same values from the corner datastructure as used in step 2012 (ori_x, tar_x, ori_y and tar_y). Thelengths determined for the two edges are compared to the minimum concavecorner edge length value in the relationship_master.

In step 2018, the notch rule is checked. This rule requires that a‘notch’ in an island have at least a specified minimum width. Framed interms of corners, the rule requires that two adjacent concave corners beat least a specified distance apart. This rule need be checked for ahorizontally-adjacent corner only of the horizontally-adjacent corner isconcave, and need be checked for a vertically-adjacent corner only ofthe vertically-adjacent corner is concave. For example, in theillustration of FIG. 11B, only the horizontally-adjacent corner need bechecked for violation of the notch rule. The notch rule can be tested bysubtracting the x-position of the current corner (ori_x) from thex-position of the nearest vertical facing edge, walking horizontallyfrom corner, away from the shape, which is already available in thecurrent corner data structure as space_ray_x. The absolute value of thedifference is then compared to the minimum notch width value in therelationship_master. For a notch formed with a vertically-adjacentconcave corner, the y-position of the current corner (ori_y) issubtracted from the y-position of the nearest horizontal facing edge,walking vertically from the current corner, away from the shape, whichis already available in the current corner data structure asspace_ray_y. The absolute value of the difference is then compared tothe minimum notch width value in the relationship_master.

If in step 2014, it is determined that the current corner is convex,then in step 2020 the convex corner edge length rule is checked. Thisrule requires that at least one of the two adjacent edges forming aconvex corner have at least a minimum length. This test can be performedusing the same values from the corner data structure as used in step2012 (ori_x, tar_x, ori_y and tar_y). The lengths determined for the twoedges are compared to the minimum convex corner edge length value in therelationship_master.

In step 2022, an end-of-line spacing rule is checked. In its simplestform, this rule requires that at the end of a line, a specified minimumspacing is required to the neighboring geometry. Referring to FIG. 19D,where the line in question is line 1926, the rule requires that for anend-of-line width eolWidth less than one specified value, theend-of-line spacing eolSpace must be at least another specified value.If the current corner is convex corner 1828, then the width of the line1926 in the horizontal dimension is easily determined by subtracting thex-position of the current corner (ori_x) from the x-position of the lastvertical edge walking horizontally into shape, before exiting shape,which is already available in the current corner data structure asd_ray_x. The spacing to the next neighboring geometry is available inthe current corner data structure as s_ray_y. Thus the absolute value ofthe subtraction is compared to the value for eolWidth in therelationship_master, and if small enough to invoke the rule, s_ray_y isthen compared to the value for eolSpace in the relationship_master. Fora horizontally-oriented line, the width of the line in the verticaldimension is determined by subtracting the y-position of the currentcorner (ori_y) from the y-position of the last horizontal edge walkingvertically into shape, before exiting shape, which is already availablein the current corner data structure as d_ray_y. The spacing to the nextneighboring geometry is available in the current corner data structureas s_ray_x. Thus the absolute value of the subtraction is compared tothe value for eolWidth in the relationship_master, and if small enoughto invoke the rule, s_ray_x is then compared to the value for eolSpacein the relationship_master.

After all the desired rules are checked for the current corner, theroutine returns to step 2010 to consider the next corner insynchronized_corner_map.

Returning to FIG. 17, after the corner-based rules have been checked insteps 1710 and 1712, island-based rules are then checked in step 1714.Example island-based design rules that can be checked here include theminimum island area rule, the minimum hole area rule, minimum common rundependent separation against other islands in the same layer, andminimum common run dependent separation against islands in other layers.In an embodiment, these are all checked within a single traversal ofisland_map, where the values for all required topological relationshipsin the layout region have already been populated. For example, the areaof each island in island_map has already been populated during thehorizontal scan. The step of checking the minimum island area rule,therefore, is accomplished simply by comparing the stored island areafor the current island with the minimum area value in therelationship_master. Note that in an embodiment, during the horizontalscan, accumulation of island area is aborted once the accumulated areaexceeds the worst case minimum required in the relationship_master. Thestored area values will still be determined in this step 1714 to satisfythe minimum island area rule.

Other rules, such as via-based rules, are checked in step 1716.

Returning to FIG. 3, step 324 involves reporting any design ruleviolations to the user or to another entity. If reported to the user,the report can take place promptly (e.g. for real time feedback) orlater (e.g. if performed as a batch job). Where the violations arereported to the user promptly, this enables the user to modify thelayout to correct for the design rule violations. Whereas any form ofreporting can be used, preferably the design rule violations arereported by way of visual indications on the user's monitor, as markerson the layout region itself. In an embodiment, near violations are alsoindicated. Marker information can be anything that can be used to rendera visual indicator of the violation, but preferably it identifies arectangle for designating the location of the violation within thelayout region. In an embodiment, the rectangle is shown in a size whichindicates the magnitude of the primary value of the rule being violated.This information can be very useful as it indicates graphically how muchis needed to correct the violation. For near-violations, it can be aruler indicating the current spacing. For example, if the violation is aminimum spacing violation, a rectangle might encompass the (too-small)spacing area, or a ruler disposed across the space might indicate actualspacing if it is larger than the minimum.

All of the design rule checks output marker information for anyviolation. The marker information is collected in a map structure. Instep 324, the marker information is converted to visible form on theuser's monitor or provided to another entity. In addition, as shown inFIG. 3, once the markers have been output, the system returns to step312 to await the next editing command. This may be as simple as anotherslight movement of the current editing shapes being dragged across thelayout region. This event will result in another traversal through steps314-324 of FIG. 3, thus causing a change in the visual indicator as seenby the user. Because of the efficiency of the design rule checkingtechniques described herein, in the embodiment herein the new markingswill appear nearly immediately with each drag of the editing shapes.

FIG. 21A is an example visual indication of a violation of a minimumspacing rule. In this drawing, editing rectangle 2112 has been moved tooclose to static rectangle 2110, and a box 2114 appears indicating howmuch end-of-line spacing is required by the rule. If the minimum spacingvalue that is being violated is an absolute value, then the box 2114might appear in one color, whereas if it is a preferred value that isbeing violated, then the box 2114 might appear in another color. A thirdcolor can be used to indicate a most preferred value, and so on. As theuser pulls the editing shape 2112 apart from static shape 2110, the box2114 disappears and a ruler appears, such as ruler 2116 in FIG. 21B.Ruler 2116 indicates the actual distance between the end of editingshape 2112 and the nearest edge of static shape 2110, and therebyindicates how much closer shape 2112 can be brought to shape 2110 beforethe minimum spacing rule will be violated.

FIG. 21C is an example visual indication of a violation of acorner-to-corner spacing rule. In this drawing, editing rectangle 2112has been moved too close to a corner of static rectangle 2110, and a box2118 appears indicating the violation. Again, the box 2118 can appear ineither of two colors to indicate violation of an absolute or preferredvalue for this design rule. As the user pulls the editing shape 2112apart from static shape 2110, the box 2114 disappears and a rulerappears, such as corner-to-corner ruler 2120 in FIG. 21D. Ruler 2020indicates the actual corner-to-corner distance between the end ofediting shape 2112 and the nearest edge of static shape 2110.

FIG. 21E is an example visual indication of a violation of acorner-to-corner minimum dimension rule. In this drawing, a corner ofediting rectangle 2112 overlaps a corner of a same layer staticrectangle 2110, but the overlap is too small to satisfy the minimumdimension rule. A box 2022 appears indicating the violation.

Similar visual indicators to indicate violations of other design ruleswill be apparent to the reader. It can be seen that the markings providenearly immediate feedback to the user as the layout is edited, therebygreatly facilitating the manual layout effort. It should be noted thatthe absence of any visual indication to the user also constitutes anotification to the user that no design rule violation has beendetected.

In the embodiments described herein, all the corner data structures arecompletely populated before the corner-based rules are checked. This isthe most advantageous arrangement, but some benefits of the inventioncan be obtained even if only some (i.e. more than one; preferably morethan two) of the corner data structures are completely populated beforethe corner-based rules are checked. Similarly, all island datastructures are completely populated before the island-based rules arechecked. Again, while this is the most advantageous arrangement, somebenefits of the invention can be obtained even if only some (i.e. morethan one; preferably more than two) of the island data structures arecompletely populated before the island-based rules are checked.

Hardware

FIG. 22 is a simplified block diagram of a computer system 2210 that canbe used to implement software incorporating aspects of the presentinvention. Computer system 2210 includes a processor subsystem 2214which communicates with a number of peripheral devices via bus subsystem2212. These peripheral devices may include a storage subsystem 2224,comprising a memory subsystem 2226 and a file storage subsystem 2228,user interface input devices 2222, user interface output devices 2220,and a network interface subsystem 2216. The input and output devicesallow user interaction with computer system 2210. Network interfacesubsystem 2216 provides an interface to outside networks, including aninterface to communication network 2218, and is coupled viacommunication network 2218 to corresponding interface devices in othercomputer systems. Communication network 2218 may comprise manyinterconnected computer systems and communication links. Thesecommunication links may be wireline links, optical links, wirelesslinks, or any other mechanisms for communication of information. Whilein one embodiment, communication network 2218 is the Internet, in otherembodiments, communication network 2218 may be any suitable computernetwork.

The physical hardware component of network interfaces are sometimesreferred to as network interface cards (NICs), although they need not bein the form of cards: for instance they could be in the form ofintegrated circuits (ICs) and connectors fitted directly onto amotherboard, or in the form of macrocells fabricated on a singleintegrated circuit chip with other components of the computer system.

User interface input devices 2222 may include a keyboard, pointingdevices such as a mouse, trackball, touchpad, or graphics tablet, ascanner, a touch screen incorporated into the display, audio inputdevices such as voice recognition systems, microphones, and other typesof input devices. In general, use of the term “input device” is intendedto include all possible types of devices and ways to input informationinto computer system 2210 or onto computer network 2218.

User interface output devices 2220 may include a display subsystem, aprinter, a fax machine, or non-visual displays such as audio outputdevices. The display subsystem may include a cathode ray tube (CRT), aflat-panel device such as a liquid crystal display (LCD), a projectiondevice, or some other mechanism for creating a visible image. Thedisplay subsystem produces the images illustrated in FIGS. 21A-21E, forexample. The display subsystem may also provide non-visual display suchas via audio output devices. In general, use of the term “output device”is intended to include all possible types of devices and ways to outputinformation from computer system 2210 to the user or to another machineor computer system.

Storage subsystem 2224 stores the basic programming and data constructsthat provide the functionality of certain embodiments of the presentinvention. For example, the various modules implementing thefunctionality of certain embodiments of the invention may be stored instorage subsystem 2224. These software modules are generally executed byprocessor subsystem 2214.

Memory subsystem 2226 typically includes a number of memories includinga main random access memory (RAM) 2230 for storage of instructions anddata during program execution and a read only memory (ROM) 2232 in whichfixed instructions are stored. File storage subsystem 2228 providespersistent storage for program and data files, and may include a harddisk drive, a floppy disk drive along with associated removable media, aCD-ROM drive, an optical drive, or removable media cartridges. Thedatabases and modules implementing the functionality of certainembodiments of the invention may be stored by file storage subsystem2228. The host memory 2226 contains, among other things, computerinstructions which, when executed by the processor subsystem 2214, causethe computer system to operate or perform functions as described herein.As used herein, processes and software that are said to run in or on“the host” or “the computer system”, execute on the processor subsystem2214 in response to computer instructions and data in the host memorysubsystem 2226 including any other local or remote storage for suchinstructions and data.

Bus subsystem 2212 provides a mechanism for letting the variouscomponents and subsystems of computer system 2210 communicate with eachother as intended. Although bus subsystem 2212 is shown schematically asa single bus, alternative embodiments of the bus subsystem may usemultiple busses.

Computer system 2210 itself can be of varying types including a personalcomputer, a portable computer, a workstation, a computer terminal, anetwork computer, a television, a mainframe, or any other dataprocessing system or user device. Due to the ever-changing nature ofcomputers and networks, the description of computer system 2210 depictedin FIG. 22 is intended only as a specific example for purposes ofillustrating certain embodiments of the present invention. In anotherembodiment, the invention can be implemented using multiple computersystems, such as in a server farm. Many other configurations of computersystem 2210 are possible having more or less components than thecomputer system depicted in FIG. 22.

In an embodiment, the steps set forth in the flow charts anddescriptions herein are performed by a computer system having aprocessor such as processor subsystem 2214 and a memory such as storagesubsystem 2224, under the control of software which includesinstructions which are executable by the processor subsystem 2214 toperform the steps shown. The software also includes data on which theprocessor operates. The software is stored on a computer readablemedium, which as mentioned above and as used herein, is one on whichinformation can be stored and read by a computer system. Examplesinclude a floppy disk, a hard disk drive, a RAM, a CD, a DVD, flashmemory, a USB drive, and so on. The computer readable medium may storeinformation in coded formats that are decoded for actual use in aparticular data processing system. A single computer readable medium, asthe term is used herein, may also include more than one physical item,such as a plurality of CD-ROMs or a plurality of segments of RAM, or acombination of several different kinds of media. When the computerreadable medium storing the software is combined with the computersystem of FIG. 22, the combination is a machine which performs the stepsset forth herein. Means for performing each step consists of thecomputer system (or only those parts of it that are needed for the step)in combination with software modules for performing the step. Thecomputer readable medium storing the software is also capable of beingdistributed separately from the computer system, and forms its ownarticle of manufacture.

Additionally, the geometry file or files storing the layout, therelationship master dataset, and the layout topology database arethemselves stored on computer readable media. Such media can bedistributable separately from the computer system, and form their ownrespective articles of manufacture. When combined with a computer systemprogrammed with software for reading, revising, and writing the geometryfiles, and for design rule checking, they form yet another machine whichperforms the steps set forth herein.

As used herein, the “identification” of an item of information does notnecessarily require the direct specification of that item ofinformation. Information can be “identified” in a field by simplyreferring to the actual information through one or more layers ofindirection, or by identifying one or more items of differentinformation which are together sufficient to determine the actual itemof information. In addition, the term “indicate” is used herein to meanthe same as “identify”.

As used herein, a given signal, event or value is “responsive” to apredecessor signal, event or value if the predecessor signal, event orvalue influenced the given signal, event or value. If there is anintervening processing element, step or time period, the given signal,event or value can still be “responsive” to the predecessor signal,event or value. If the intervening processing element or step combinesmore than one signal, event or value, the signal output of theprocessing element or step is considered “responsive” to each of thesignal, event or value inputs. If the given signal, event or value isthe same as the predecessor signal, event or value, this is merely adegenerate case in which the given signal, event or value is stillconsidered to be “responsive” to the predecessor signal, event or value.“Dependency” of a given signal, event or value upon another signal,event or value is defined similarly.

The foregoing description of preferred embodiments of the presentinvention has been provided for the purposes of illustration anddescription. It is not intended to be exhaustive or to limit theinvention to the precise forms disclosed. Obviously, many modificationsand variations will be apparent to practitioners skilled in this art. Inparticular, and without limitation, any and all variations described,suggested or incorporated by reference in the Background section of thispatent application are specifically incorporated by reference into thedescription herein of embodiments of the invention. The embodimentsdescribed herein were chosen and described in order to best explain theprinciples of the invention and its practical application, therebyenabling others skilled in the art to understand the invention forvarious embodiments and with various modifications as are suited to theparticular use contemplated. It is intended that the scope of theinvention be defined by the following claims and their equivalents.

We claim:
 1. A system for checking a set of layout design rules on aregion of an integrated circuit layout, the layout including a pluralityof shapes each having shape corners at respective locations in thelayout, the system comprising: a computer system having access to adesign rule data set indicating constraint values of design rules in thedata set, the computer system further having access to computerinstructions and data which, when applied to the computer system,perform the steps of: traversing a plurality of shape corners of shapesin the region; for each particular one of the traversed shape corners,populating a layout topology database with an association between (1) anidentification of the particular shape corner and (2) one or moreparticular values which depend upon the particular shape cornerlocation; comparing values in the layout topology database to values inthe design rule data set to detect any violations of design rules in theset of design rules; and where a design rule violation is detected,reporting it to a user.
 2. A system according to claim 1, wherein theparticular values populated into the database for each of the particularshape corners include indications of two edges which meet at theparticular corner.
 3. A system according to claim 1, wherein theparticular values populated into the database for each of the particularshape corners include an indication of the nearest edge oriented in afirst dimension, walking perpendicularly to the first dimension alongthe shape contour from the particular corner.
 4. A system according toclaim 1, wherein the particular values populated into the database foreach of the particular shape corners include an indication of thenearest facing edge that is oriented in a first dimension, walkingperpendicularly to the first dimension along the shape contour from theparticular corner.
 5. A system according to claim 1, wherein theparticular values populated into the database for each of the particularshape corners include an indication of the last edge that is oriented ina first dimension, walking perpendicularly to the first dimension fromthe particular corner and into the shape on which the particular cornerlies, before exiting the shape on which the particular corner lies.
 6. Asystem according to claim 1, wherein the particular values populatedinto the database for each of the particular shape corners include anindication of the number of shapes in the plurality of shapes whichborder on the particular corner and occupy each of four quadrantscentered at the particular corner.
 7. A system according to claim 1,wherein the particular values populated into the database for each ofthe particular shape corners include an indication of the number ofshapes in the plurality of shapes which border on the particular cornerand occupy each of eight octants centered at the particular corner.
 8. Amethod for real time editing of a region of an integrated circuitlayout, the layout including a plurality of objects, for use with acomputer system having access to a design rule data set indicatingconstraint values of design rules in the data set, the method comprisingthe steps of: through first user behavior communicated to the computersystem, selecting a group of editing objects from among those in theintegrated circuit layout, the editing objects upon selection having afirst position in the layout; through second user behavior communicatedto the computer system, commanding the computer system to move theediting objects to a second position in the layout; and sufficientlypromptly after the second user behavior so that the user can furtheradjust the position of the editing objects in real time, receivinguser-perceptible feedback indicating at least one member of the groupconsisting of (a) a distance by which the editing objects must be movedto avoid a first design rule violation that is incurred when the editingobjects are in the second position, and (b) the existence of anear-violation of a design rule when the editing objects are in thesecond position.
 9. A method according to claim 8, wherein the feedbackcomprises visual feedback.
 10. A method according to claim 8, whereinthe second user behavior comprises performing a drag operation with apointing device, and wherein the feedback is received by the user beforethe drag operation is ended.
 11. A method according to claim 8, whereinthe second user behavior comprises moving a mouse with a mouse buttondepressed, and wherein the feedback is received by the user before themouse button is released.
 12. A method according to claim 8, wherein thefeedback indicating a near-violation of a design rule further indicatesa distance by which the editing objects can be moved from the secondposition before the design rule violation is incurred.